home *** CD-ROM | disk | FTP | other *** search
/ Mac Easy 2010 May / Mac Life Ubuntu.iso / casper / filesystem.squashfs / usr / lib / python2.6 / dist-packages / ufw / backend.pyc (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2009-04-20  |  15.6 KB  |  560 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.6)
  3.  
  4. import os
  5. import re
  6. import stat
  7. from stat import *
  8. import sys
  9. import ufw.util as ufw
  10. from ufw.util import warn, debug
  11. from ufw.common import UFWError, config_dir, UFWRule
  12. import ufw.applications as ufw
  13.  
  14. class UFWBackend:
  15.     '''Interface for backends'''
  16.     
  17.     def __init__(self, name, d, extra_files = { }):
  18.         self.defaults = { }
  19.         self.name = name
  20.         self.dryrun = d
  21.         self.rules = []
  22.         self.rules6 = []
  23.         self.files = {
  24.             'defaults': os.path.join(config_dir, 'default/ufw'),
  25.             'conf': os.path.join(config_dir, 'ufw/ufw.conf'),
  26.             'apps': os.path.join(config_dir, 'ufw/applications.d') }
  27.         self.files.update(extra_files)
  28.         self.loglevels = {
  29.             'off': 0,
  30.             'low': 100,
  31.             'medium': 200,
  32.             'high': 300,
  33.             'full': 400 }
  34.         self.do_checks = True
  35.         
  36.         try:
  37.             self._do_checks()
  38.             self._get_defaults()
  39.             self._read_rules()
  40.         except Exception:
  41.             raise 
  42.  
  43.         self.profiles = ufw.applications.get_profiles(self.files['apps'])
  44.         self.iptables_version = ufw.util.get_iptables_version()
  45.  
  46.     
  47.     def _is_enabled(self):
  48.         if self.defaults.has_key('enabled') and self.defaults['enabled'] == 'yes':
  49.             return True
  50.         return False
  51.  
  52.     
  53.     def use_ipv6(self):
  54.         if self.defaults.has_key('ipv6') and self.defaults['ipv6'] == 'yes' and os.path.exists('/proc/sys/net/ipv6'):
  55.             return True
  56.         return False
  57.  
  58.     
  59.     def _do_checks(self):
  60.         """Perform basic security checks:
  61.         is setuid or setgid (for non-Linux systems)
  62.         checks that script is owned by root
  63.         checks that every component in absolute path are owned by root
  64.         warn if script is group writable
  65.         warn if part of script path is group writable
  66.  
  67.         Doing this at the beginning causes a race condition with later
  68.         operations that don't do these checks.  However, if the user running
  69.         this script is root, then need to be root to exploit the race
  70.         condition (and you are hosed anyway...)
  71.         """
  72.         if not self.do_checks:
  73.             err_msg = _('Checks disabled')
  74.             warn(err_msg)
  75.             return True
  76.         if os.getuid() != os.geteuid():
  77.             err_msg = _('ERROR: this script should not be SUID')
  78.             raise UFWError(err_msg)
  79.         os.getuid() != os.geteuid()
  80.         if os.getgid() != os.getegid():
  81.             err_msg = _('ERROR: this script should not be SGID')
  82.             raise UFWError(err_msg)
  83.         os.getgid() != os.getegid()
  84.         uid = os.getuid()
  85.         if uid != 0:
  86.             err_msg = _('You need to be root to run this script')
  87.             raise UFWError(err_msg)
  88.         uid != 0
  89.         warned_world_write = { }
  90.         warned_group_write = { }
  91.         warned_owner = { }
  92.         profiles = []
  93.         if not os.path.isdir(self.files['apps']):
  94.             warn_msg = _("'%s' does not exist") % self.files['apps']
  95.             warn(warn_msg)
  96.         else:
  97.             pat = re.compile('^\\.')
  98.             for profile in os.listdir(self.files['apps']):
  99.                 if not pat.search(profile):
  100.                     profiles.append(os.path.join(self.files['apps'], profile))
  101.                     continue
  102.             
  103.         for path in self.files.values() + [
  104.             os.path.abspath(sys.argv[0])] + profiles:
  105.             while True:
  106.                 debug('Checking ' + path)
  107.                 if path == self.files['apps'] and not os.path.isdir(self.files['apps']):
  108.                     break
  109.                 
  110.                 
  111.                 try:
  112.                     statinfo = os.stat(path)
  113.                     mode = statinfo[ST_MODE]
  114.                 except OSError:
  115.                     e = None
  116.                     err_msg = _("Couldn't stat '%s'") % path
  117.                     raise UFWError(err_msg)
  118.                 except Exception:
  119.                     raise 
  120.  
  121.                 if statinfo.st_uid != 0 and not warned_owner.has_key(path):
  122.                     warn_msg = _("uid is %s but '%s' is owned by %s") % (str(uid), path, str(statinfo.st_uid))
  123.                     warn(warn_msg)
  124.                     warned_owner[path] = True
  125.                 
  126.                 if mode & S_IWOTH and not warned_world_write.has_key(path):
  127.                     warn_msg = _('%s is world writable!') % path
  128.                     warn(warn_msg)
  129.                     warned_world_write[path] = True
  130.                 
  131.                 if mode & S_IWGRP and not warned_group_write.has_key(path):
  132.                     warn_msg = _('%s is group writable!') % path
  133.                     warn(warn_msg)
  134.                     warned_group_write[path] = True
  135.                 
  136.                 if path == '/':
  137.                     break
  138.                 
  139.                 path = os.path.dirname(path)
  140.                 if not path:
  141.                     raise 
  142.                 path
  143.         
  144.         for f in self.files:
  145.             if f != 'apps' and not os.path.isfile(self.files[f]):
  146.                 err_msg = _("'%s' file '%s' does not exist") % (f, self.files[f])
  147.                 raise UFWError(err_msg)
  148.             not os.path.isfile(self.files[f])
  149.         
  150.  
  151.     
  152.     def _get_defaults(self):
  153.         '''Get all settings from defaults file'''
  154.         self.defaults = { }
  155.         for f in [
  156.             self.files['defaults'],
  157.             self.files['conf']]:
  158.             
  159.             try:
  160.                 orig = ufw.util.open_file_read(f)
  161.             except Exception:
  162.                 err_msg = _("Couldn't open '%s' for reading") % f
  163.                 raise UFWError(err_msg)
  164.  
  165.             pat = re.compile('^\\w+="?\\w+"?')
  166.             for line in orig:
  167.                 if pat.search(line):
  168.                     tmp = re.split('=', line.strip())
  169.                     self.defaults[tmp[0].lower()] = tmp[1].lower().strip('"\'')
  170.                     continue
  171.             
  172.             orig.close()
  173.         
  174.  
  175.     
  176.     def set_default(self, f, opt, value):
  177.         '''Sets option in defaults file'''
  178.         if not re.match('^[\\w_]+$', opt):
  179.             err_msg = _('Invalid option')
  180.             raise UFWError(err_msg)
  181.         re.match('^[\\w_]+$', opt)
  182.         
  183.         try:
  184.             fns = ufw.util.open_files(f)
  185.         except Exception:
  186.             raise 
  187.  
  188.         fd = fns['tmp']
  189.         found = False
  190.         pat = re.compile('^' + opt + '=')
  191.         for line in fns['orig']:
  192.             if pat.search(line):
  193.                 os.write(fd, opt + '=' + value + '\n')
  194.                 found = True
  195.                 continue
  196.             os.write(fd, line)
  197.         
  198.         if not found:
  199.             os.write(fd, opt + '=' + value + '\n')
  200.         
  201.         ufw.util.close_files(fns)
  202.         self.defaults[opt.lower()] = value.lower().strip('"\'')
  203.  
  204.     
  205.     def set_default_application_policy(self, policy):
  206.         '''Sets default application policy of firewall'''
  207.         if not self.dryrun:
  208.             if policy == 'allow':
  209.                 self.set_default(self.files['defaults'], 'DEFAULT_APPLICATION_POLICY', '"ACCEPT"')
  210.             elif policy == 'deny':
  211.                 self.set_default(self.files['defaults'], 'DEFAULT_APPLICATION_POLICY', '"DROP"')
  212.             elif policy == 'reject':
  213.                 self.set_default(self.files['defaults'], 'DEFAULT_APPLICATION_POLICY', '"REJECT"')
  214.             elif policy == 'skip':
  215.                 self.set_default(self.files['defaults'], 'DEFAULT_APPLICATION_POLICY', '"SKIP"')
  216.             else:
  217.                 err_msg = _("Unsupported policy '%s'") % policy
  218.                 raise UFWError(err_msg)
  219.         policy == 'allow'
  220.         rstr = _("Default application policy changed to '%s'") % policy
  221.         return rstr
  222.  
  223.     
  224.     def get_app_rules_from_template(self, template):
  225.         '''Return a list of UFWRules based on the template rule'''
  226.         rules = []
  227.         profile_names = self.profiles.keys()
  228.         if template.dport in profile_names and template.sport in profile_names:
  229.             dports = ufw.applications.get_ports(self.profiles[template.dport])
  230.             sports = ufw.applications.get_ports(self.profiles[template.sport])
  231.             for i in dports:
  232.                 tmp = template.dup_rule()
  233.                 tmp.dapp = ''
  234.                 tmp.set_port('any', 'src')
  235.                 
  236.                 try:
  237.                     (port, proto) = ufw.util.parse_port_proto(i)
  238.                     tmp.set_protocol(proto)
  239.                     tmp.set_port(port, 'dst')
  240.                 except Exception:
  241.                     raise 
  242.  
  243.                 tmp.dapp = template.dapp
  244.                 if template.dport == template.sport:
  245.                     tmp.sapp = ''
  246.                     
  247.                     try:
  248.                         (port, proto) = ufw.util.parse_port_proto(i)
  249.                         tmp.set_protocol(proto)
  250.                         tmp.set_port(port, 'src')
  251.                     except Exception:
  252.                         raise 
  253.  
  254.                     tmp.sapp = template.sapp
  255.                     rules.append(tmp)
  256.                     continue
  257.                 for j in sports:
  258.                     rule = tmp.dup_rule()
  259.                     rule.sapp = ''
  260.                     
  261.                     try:
  262.                         (port, proto) = ufw.util.parse_port_proto(j)
  263.                         rule.set_protocol(proto)
  264.                         rule.set_port(port, 'src')
  265.                     except Exception:
  266.                         raise 
  267.  
  268.                     if rule.protocol == 'any':
  269.                         rule.set_protocol(tmp.protocol)
  270.                     
  271.                     rule.sapp = template.sapp
  272.                     rules.append(rule)
  273.                 
  274.             
  275.         elif template.sport in profile_names:
  276.             for p in ufw.applications.get_ports(self.profiles[template.sport]):
  277.                 rule = template.dup_rule()
  278.                 rule.sapp = ''
  279.                 
  280.                 try:
  281.                     (port, proto) = ufw.util.parse_port_proto(p)
  282.                     rule.set_protocol(proto)
  283.                     rule.set_port(port, 'src')
  284.                 except Exception:
  285.                     raise 
  286.  
  287.                 rule.sapp = template.sapp
  288.                 rules.append(rule)
  289.             
  290.         elif template.dport in profile_names:
  291.             for p in ufw.applications.get_ports(self.profiles[template.dport]):
  292.                 rule = template.dup_rule()
  293.                 rule.dapp = ''
  294.                 
  295.                 try:
  296.                     (port, proto) = ufw.util.parse_port_proto(p)
  297.                     rule.set_protocol(proto)
  298.                     rule.set_port(port, 'dst')
  299.                 except Exception:
  300.                     raise 
  301.  
  302.                 rule.dapp = template.dapp
  303.                 rules.append(rule)
  304.             
  305.         
  306.         if len(rules) < 1:
  307.             err_msg = _('No rules found for application profile')
  308.             raise UFWError(err_msg)
  309.         len(rules) < 1
  310.         return rules
  311.  
  312.     
  313.     def update_app_rule(self, profile):
  314.         '''Update rule for profile in place. Returns result string and bool
  315.            on whether or not the profile is used in the current ruleset.
  316.         '''
  317.         updated_rules = []
  318.         updated_rules6 = []
  319.         last_tuple = ''
  320.         rstr = ''
  321.         updated_profile = False
  322.         for r in self.rules + self.rules6:
  323.             if r.dapp == profile or r.sapp == profile:
  324.                 tuple = r.get_app_tuple()
  325.                 if tuple == last_tuple:
  326.                     continue
  327.                 else:
  328.                     template = r.dup_rule()
  329.                     template.set_protocol('any')
  330.                     if template.dapp != '':
  331.                         template.set_port(template.dapp, 'dst')
  332.                     
  333.                     if template.sapp != '':
  334.                         template.set_port(template.sapp, 'src')
  335.                     
  336.                     
  337.                     try:
  338.                         new_app_rules = self.get_app_rules_from_template(template)
  339.                     except Exception:
  340.                         raise 
  341.  
  342.                     for new_r in new_app_rules:
  343.                         new_r.normalize()
  344.                         if new_r.v6:
  345.                             updated_rules6.append(new_r)
  346.                             continue
  347.                         updated_rules.append(new_r)
  348.                     
  349.                     last_tuple = tuple
  350.                     updated_profile = True
  351.             tuple == last_tuple
  352.             if r.v6:
  353.                 updated_rules6.append(r)
  354.                 continue
  355.             updated_rules.append(r)
  356.         
  357.         if updated_profile:
  358.             self.rules = updated_rules
  359.             self.rules6 = updated_rules6
  360.             rstr += _("Rules updated for profile '%s'") % profile
  361.             
  362.             try:
  363.                 self._write_rules(False)
  364.                 self._write_rules(True)
  365.             except Exception:
  366.                 err_msg = _("Couldn't update application rules")
  367.                 raise UFWError(err_msg)
  368.             except:
  369.                 None<EXCEPTION MATCH>Exception
  370.             
  371.  
  372.         None<EXCEPTION MATCH>Exception
  373.         return (rstr, updated_profile)
  374.  
  375.     
  376.     def find_application_name(self, str):
  377.         '''Find the application profile name for str'''
  378.         if self.profiles.has_key(str):
  379.             return str
  380.         match = ''
  381.         matches = 0
  382.         for n in self.profiles.keys():
  383.             if n.lower() == str.lower():
  384.                 match = n
  385.                 matches += 1
  386.                 continue
  387.             self.profiles.has_key(str)
  388.         
  389.         debug_msg = "'%d' matches for '%s'" % (matches, str)
  390.         debug(debug_msg)
  391.         if matches == 1:
  392.             return match
  393.         if matches > 1:
  394.             err_msg = _("Found multiple matches for '%s'. Please use exact profile name") % str
  395.         
  396.         err_msg = _("Could not find a profile matching '%s'") % str
  397.         raise UFWError(err_msg)
  398.  
  399.     
  400.     def find_other_position(self, position, v6):
  401.         """Return the absolute position in the other list of the rule with the
  402. \t   user position of the given list. For example, find_other_position(4,
  403. \t   True) will return the absolute position of the rule in the ipv4 list
  404.            matching the user specified '4' rule in the ipv6 list.
  405.         """
  406.         if v6 and position > len(self.rules6):
  407.             raise ValueError()
  408.         position > len(self.rules6)
  409.         if not v6 and position > len(self.rules):
  410.             raise ValueError()
  411.         position > len(self.rules)
  412.         if position < 1:
  413.             raise ValueError()
  414.         position < 1
  415.         rules = []
  416.         if v6:
  417.             rules = self.rules6
  418.         else:
  419.             rules = self.rules
  420.         app_rules = { }
  421.         tuple_offset = 0
  422.         for i, r in enumerate(rules):
  423.             if i >= position:
  424.                 break
  425.             
  426.             tuple = ''
  427.             if r.dapp != '' or r.sapp != '':
  428.                 tuple = r.get_app_tuple()
  429.                 if app_rules.has_key(tuple):
  430.                     tuple_offset += 1
  431.                 else:
  432.                     app_rules[tuple] = True
  433.             app_rules.has_key(tuple)
  434.         
  435.         rules = []
  436.         if v6:
  437.             rules = self.rules
  438.             match_rule = self.rules6[(position - 1) + tuple_offset].dup_rule()
  439.             match_rule.set_v6(False)
  440.         else:
  441.             rules = self.rules6
  442.             match_rule = self.rules[(position - 1) + tuple_offset].dup_rule()
  443.             match_rule.set_v6(True)
  444.         count = 1
  445.         for r in rules:
  446.             if UFWRule.match(r, match_rule) == 0:
  447.                 return count
  448.             count += 1
  449.         
  450.         return 0
  451.  
  452.     
  453.     def get_loglevel(self):
  454.         '''Gets current log level of firewall'''
  455.         level = 0
  456.         rstr = _('Logging: ')
  457.         if not self.defaults.has_key('loglevel') or self.defaults['loglevel'] not in self.loglevels.keys():
  458.             level = -1
  459.             rstr += _('unknown')
  460.         else:
  461.             level = self.loglevels[self.defaults['loglevel']]
  462.             if level == 0:
  463.                 rstr += 'off'
  464.             else:
  465.                 rstr += 'on (%s)' % self.defaults['loglevel']
  466.         return (level, rstr)
  467.  
  468.     
  469.     def set_loglevel(self, level):
  470.         '''Sets log level of firewall'''
  471.         if level not in self.loglevels.keys() + [
  472.             'on']:
  473.             err_msg = _("Invalid log level '%s'") % level
  474.             raise UFWError(err_msg)
  475.         level not in self.loglevels.keys() + [
  476.             'on']
  477.         new_level = level
  478.         if level == 'on':
  479.             if not self.defaults.has_key('loglevel') or self.defaults['loglevel'] == 'off':
  480.                 new_level = 'low'
  481.             else:
  482.                 new_level = self.defaults['loglevel']
  483.         
  484.         self.set_default(self.files['conf'], 'LOGLEVEL', new_level)
  485.         
  486.         try:
  487.             self.update_logging(new_level)
  488.         except:
  489.             raise 
  490.  
  491.         if new_level == 'off':
  492.             return _('Logging disabled')
  493.         return _('Logging enabled')
  494.  
  495.     
  496.     def get_rules_count(self, v6):
  497.         '''Return number of ufw rules (not iptables rules)'''
  498.         rules = []
  499.         if v6:
  500.             rules = self.rules6
  501.         else:
  502.             rules = self.rules
  503.         count = 0
  504.         app_rules = { }
  505.         for r in rules:
  506.             tuple = ''
  507.             if r.dapp != '' or r.sapp != '':
  508.                 tuple = r.get_app_tuple()
  509.                 if app_rules.has_key(tuple):
  510.                     debug("Skipping found tuple '%s'" % tuple)
  511.                     continue
  512.                 else:
  513.                     app_rules[tuple] = True
  514.             
  515.             count += 1
  516.         
  517.         return count
  518.  
  519.     
  520.     def get_default_policy(self):
  521.         raise UFWError('UFWBackend.get_default_policy: need to override')
  522.  
  523.     
  524.     def set_default_policy(self, policy):
  525.         raise UFWError('UFWBackend.set_default_policy: need to override')
  526.  
  527.     
  528.     def get_running_raw(self):
  529.         raise UFWError('UFWBackend.get_running_raw: need to override')
  530.  
  531.     
  532.     def get_status(self, verbose, show_count):
  533.         raise UFWError('UFWBackend.get_status: need to override')
  534.  
  535.     
  536.     def get_status_as_list(self):
  537.         raise UFWError('UFWBackend.get_status_as_list: need to override')
  538.  
  539.     
  540.     def set_rule(self, rule, allow_reload):
  541.         raise UFWError('UFWBackend.set_rule: need to override')
  542.  
  543.     
  544.     def start_firewall(self):
  545.         raise UFWError('UFWBackend.start_firewall: need to override')
  546.  
  547.     
  548.     def stop_firewall(self):
  549.         raise UFWError('UFWBackend.stop_firewall: need to override')
  550.  
  551.     
  552.     def get_app_rules_from_system(self, template, v6):
  553.         raise UFWError('UFWBackend.get_app_rules_from_system: need to ' + 'override')
  554.  
  555.     
  556.     def update_logging(self, level):
  557.         raise UFWError('UFWBackend.update_logging: need to override')
  558.  
  559.  
  560.